// ///////////////////////////// MIT License //////////////////////////////////// //
//                                                                                //
// Copyright (c) 2010 David Zsolt Manrique                                        //
//                    david.zsolt.manrique@gmail.com                              //
//                                                                                //
// Permission is hereby granted, free of charge, to any person obtaining a copy   //
// of this software and associated documentation files (the "Software"), to deal  //
// in the Software without restriction, including without limitation the rights   //
// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell      //
// copies of the Software, and to permit persons to whom the Software is          //
// furnished to do so, subject to the following conditions:                       //
//                                                                                //
// The above copyright notice and this permission notice shall be included in     //
// all copies or substantial portions of the Software.                            //
//                                                                                //
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR     //
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,       //
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE    //
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER         //
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,  //
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN      //
// THE SOFTWARE.                                                                  //
//                                                                                //
// ////////////////////////////////////////////////////////////////////////////// //

#include "transportanalio.h"

using namespace std;


int main(int argc, char* argv[])
{
try
{

        
} catch(const char* message)
{
    std::cerr << message << std::endl;
    std::cerr << "(exit)" << std::endl;
    return EXIT_FAILURE;
}
catch(const std::exception & e)
{
    std::cerr << e.what() << std::endl;
    std::cerr << "(exit)" << std::endl;
    return EXIT_FAILURE;
}
    return EXIT_SUCCESS;



}


/*
int main(int argc, char* argv[])
{
try
{
        Eigen::MatrixXcd rH,rS,H,S;
        
        std::vector<Eigen::Vector3d> rc,c; 
        std::vector<std::pair<int,int> > ror;
        double ref;
        
        get_cmd(argc,argv,rc,ror,rh,rs,ref,c);
        
        Eigen::MatirxXi rh,rk,rl,h,k,l;
        Eigen::Vector3d a1,a2,a3;
        structure_hkl(rc,a1,a2,a3,rh,rk,rl);
        structure_hkl(c,a1,a2,a3,h,k,l);
        
        int rn,n;
        rn = rc.size();
        n = c.size();
    
        //> fast solution
        Eigen::MatrixXcd Hblock,Sblock;
        get_atomic_block_IJ(rH,ror,0,0,Hblock);
        H.resize(n*Hblock.rows(),n*Hblock.cols());
        S.resize(n*Hblock.rows(),n*Hblock.cols());
        H.setZero();
        S.setZero();
        
        //< end
            
        for(int i=0; i<n; i++)
        for(int j=0; j<n; j++)
        {
            int h_ = h(i,j);
            int k_ = k(i,j);
            int l_ = l(i,j);
            
            bool found = false;
            for(int ri=0; ri<rn; ri++)
            for(int rj=0; rj<rn; rj++)
            if( (h_ == rh(ir,rj))  && (k_ == rk(ir,rj)) && (l_ == rl(ir,rj)) )
            {
                get_atomic_block_IJ(rH,ror,ri,rj,Hblock);
                get_atomic_block_IJ(rS,ror,ri,rj,Sblock);
                found = true;
                break;
            }
            
            if(!found)
            {
                Hblock.setZero();
                Sblock.setZero();
            }
            
            H.block(i*Hblock.rows(),j*Hblock.cols(),Hblock.rows(),Hblock.cols()) = Hblock;
            S.block(i*Hblock.rows(),j*Hblock.cols(),Hblock.rows(),Hblock.cols()) = Sblock;
        
        }

        
} catch(const char* message)
{
    std::cerr << message << std::endl;
    std::cerr << "(exit)" << std::endl;
    return EXIT_FAILURE;
}
catch(const std::exception & e)
{
    std::cerr << e.what() << std::endl;
    std::cerr << "(exit)" << std::endl;
    return EXIT_FAILURE;
}
    return EXIT_SUCCESS;



}

*/